home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / io / ObjectInputStream.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  17.8 KB  |  994 lines
  1. package java.io;
  2.  
  3. import java.lang.reflect.Array;
  4. import java.lang.reflect.Proxy;
  5. import java.security.AccessController;
  6. import java.util.HashMap;
  7.  
  8. public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants {
  9.    private static final int NULL_HANDLE = -1;
  10.    private static final Object unsharedMarker = new Object();
  11.    private static final HashMap primClasses = new HashMap(8, 1.0F);
  12.    private final BlockDataInputStream bin;
  13.    private final ValidationList vlist;
  14.    private int depth;
  15.    private boolean closed;
  16.    private final HandleTable handles;
  17.    private int passHandle = -1;
  18.    private boolean defaultDataEnd = false;
  19.    private byte[] primVals;
  20.    private final boolean enableOverride;
  21.    private boolean enableResolve;
  22.    private CallbackContext curContext;
  23.  
  24.    public ObjectInputStream(InputStream var1) throws IOException {
  25.       this.verifySubclass();
  26.       this.bin = new BlockDataInputStream(this, var1);
  27.       this.handles = new HandleTable(10);
  28.       this.vlist = new ValidationList();
  29.       this.enableOverride = false;
  30.       this.readStreamHeader();
  31.       this.bin.setBlockDataMode(true);
  32.    }
  33.  
  34.    protected ObjectInputStream() throws IOException, SecurityException {
  35.       SecurityManager var1 = System.getSecurityManager();
  36.       if (var1 != null) {
  37.          var1.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
  38.       }
  39.  
  40.       this.bin = null;
  41.       this.handles = null;
  42.       this.vlist = null;
  43.       this.enableOverride = true;
  44.    }
  45.  
  46.    public final Object readObject() throws IOException, ClassNotFoundException {
  47.       if (this.enableOverride) {
  48.          return this.readObjectOverride();
  49.       } else {
  50.          int var1 = this.passHandle;
  51.  
  52.          Object var4;
  53.          try {
  54.             Object var2 = this.readObject0(false);
  55.             this.handles.markDependency(var1, this.passHandle);
  56.             ClassNotFoundException var3 = this.handles.lookupException(this.passHandle);
  57.             if (var3 != null) {
  58.                throw var3;
  59.             }
  60.  
  61.             if (this.depth == 0) {
  62.                this.vlist.doCallbacks();
  63.             }
  64.  
  65.             var4 = var2;
  66.          } finally {
  67.             this.passHandle = var1;
  68.             if (this.closed && this.depth == 0) {
  69.                this.clear();
  70.             }
  71.  
  72.          }
  73.  
  74.          return var4;
  75.       }
  76.    }
  77.  
  78.    protected Object readObjectOverride() throws IOException, ClassNotFoundException {
  79.       return null;
  80.    }
  81.  
  82.    public Object readUnshared() throws IOException, ClassNotFoundException {
  83.       int var1 = this.passHandle;
  84.  
  85.       Object var4;
  86.       try {
  87.          Object var2 = this.readObject0(true);
  88.          this.handles.markDependency(var1, this.passHandle);
  89.          ClassNotFoundException var3 = this.handles.lookupException(this.passHandle);
  90.          if (var3 != null) {
  91.             throw var3;
  92.          }
  93.  
  94.          if (this.depth == 0) {
  95.             this.vlist.doCallbacks();
  96.          }
  97.  
  98.          var4 = var2;
  99.       } finally {
  100.          this.passHandle = var1;
  101.          if (this.closed && this.depth == 0) {
  102.             this.clear();
  103.          }
  104.  
  105.       }
  106.  
  107.       return var4;
  108.    }
  109.  
  110.    public void defaultReadObject() throws IOException, ClassNotFoundException {
  111.       if (this.curContext == null) {
  112.          throw new NotActiveException("not in call to readObject");
  113.       } else {
  114.          Object var1 = this.curContext.getObj();
  115.          ObjectStreamClass var2 = this.curContext.getDesc();
  116.          this.bin.setBlockDataMode(false);
  117.          this.defaultReadFields(var1, var2);
  118.          this.bin.setBlockDataMode(true);
  119.          if (!var2.hasWriteObjectData()) {
  120.             this.defaultDataEnd = true;
  121.          }
  122.  
  123.          ClassNotFoundException var3 = this.handles.lookupException(this.passHandle);
  124.          if (var3 != null) {
  125.             throw var3;
  126.          }
  127.       }
  128.    }
  129.  
  130.    public GetField readFields() throws IOException, ClassNotFoundException {
  131.       if (this.curContext == null) {
  132.          throw new NotActiveException("not in call to readObject");
  133.       } else {
  134.          Object var1 = this.curContext.getObj();
  135.          ObjectStreamClass var2 = this.curContext.getDesc();
  136.          this.bin.setBlockDataMode(false);
  137.          GetFieldImpl var3 = new GetFieldImpl(this, var2);
  138.          var3.readFields();
  139.          this.bin.setBlockDataMode(true);
  140.          if (!var2.hasWriteObjectData()) {
  141.             this.defaultDataEnd = true;
  142.          }
  143.  
  144.          return var3;
  145.       }
  146.    }
  147.  
  148.    public void registerValidation(ObjectInputValidation var1, int var2) throws NotActiveException, InvalidObjectException {
  149.       if (this.depth == 0) {
  150.          throw new NotActiveException("stream inactive");
  151.       } else {
  152.          this.vlist.register(var1, var2);
  153.       }
  154.    }
  155.  
  156.    protected Class<?> resolveClass(ObjectStreamClass var1) throws IOException, ClassNotFoundException {
  157.       String var2 = var1.getName();
  158.  
  159.       try {
  160.          return Class.forName(var2, false, latestUserDefinedLoader());
  161.       } catch (ClassNotFoundException var5) {
  162.          Class var4 = (Class)primClasses.get(var2);
  163.          if (var4 != null) {
  164.             return var4;
  165.          } else {
  166.             throw var5;
  167.          }
  168.       }
  169.    }
  170.  
  171.    protected Class<?> resolveProxyClass(String[] var1) throws IOException, ClassNotFoundException {
  172.       ClassLoader var2 = latestUserDefinedLoader();
  173.       ClassLoader var3 = null;
  174.       boolean var4 = false;
  175.       Class[] var5 = new Class[var1.length];
  176.  
  177.       for(int var6 = 0; var6 < var1.length; ++var6) {
  178.          Class var7 = Class.forName(var1[var6], false, var2);
  179.          if ((var7.getModifiers() & 1) == 0) {
  180.             if (var4) {
  181.                if (var3 != var7.getClassLoader()) {
  182.                   throw new IllegalAccessError("conflicting non-public interface class loaders");
  183.                }
  184.             } else {
  185.                var3 = var7.getClassLoader();
  186.                var4 = true;
  187.             }
  188.          }
  189.  
  190.          var5[var6] = var7;
  191.       }
  192.  
  193.       try {
  194.          return Proxy.getProxyClass(var4 ? var3 : var2, var5);
  195.       } catch (IllegalArgumentException var8) {
  196.          throw new ClassNotFoundException((String)null, var8);
  197.       }
  198.    }
  199.  
  200.    protected Object resolveObject(Object var1) throws IOException {
  201.       return var1;
  202.    }
  203.  
  204.    protected boolean enableResolveObject(boolean var1) throws SecurityException {
  205.       if (var1 == this.enableResolve) {
  206.          return var1;
  207.       } else {
  208.          if (var1) {
  209.             SecurityManager var2 = System.getSecurityManager();
  210.             if (var2 != null) {
  211.                var2.checkPermission(SUBSTITUTION_PERMISSION);
  212.             }
  213.          }
  214.  
  215.          this.enableResolve = var1;
  216.          return !this.enableResolve;
  217.       }
  218.    }
  219.  
  220.    protected void readStreamHeader() throws IOException, StreamCorruptedException {
  221.       short var1 = this.bin.readShort();
  222.       short var2 = this.bin.readShort();
  223.       if (var1 != -21267 || var2 != 5) {
  224.          throw new StreamCorruptedException(String.format("invalid stream header: %04X%04X", var1, var2));
  225.       }
  226.    }
  227.  
  228.    protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
  229.       ObjectStreamClass var1 = new ObjectStreamClass();
  230.       var1.readNonProxy(this);
  231.       return var1;
  232.    }
  233.  
  234.    public int read() throws IOException {
  235.       return this.bin.read();
  236.    }
  237.  
  238.    public int read(byte[] var1, int var2, int var3) throws IOException {
  239.       if (var1 == null) {
  240.          throw new NullPointerException();
  241.       } else {
  242.          int var4 = var2 + var3;
  243.          if (var2 >= 0 && var3 >= 0 && var4 <= var1.length && var4 >= 0) {
  244.             return this.bin.read(var1, var2, var3, false);
  245.          } else {
  246.             throw new IndexOutOfBoundsException();
  247.          }
  248.       }
  249.    }
  250.  
  251.    public int available() throws IOException {
  252.       return this.bin.available();
  253.    }
  254.  
  255.    public void close() throws IOException {
  256.       this.closed = true;
  257.       if (this.depth == 0) {
  258.          this.clear();
  259.       }
  260.  
  261.       this.bin.close();
  262.    }
  263.  
  264.    public boolean readBoolean() throws IOException {
  265.       return this.bin.readBoolean();
  266.    }
  267.  
  268.    public byte readByte() throws IOException {
  269.       return this.bin.readByte();
  270.    }
  271.  
  272.    public int readUnsignedByte() throws IOException {
  273.       return this.bin.readUnsignedByte();
  274.    }
  275.  
  276.    public char readChar() throws IOException {
  277.       return this.bin.readChar();
  278.    }
  279.  
  280.    public short readShort() throws IOException {
  281.       return this.bin.readShort();
  282.    }
  283.  
  284.    public int readUnsignedShort() throws IOException {
  285.       return this.bin.readUnsignedShort();
  286.    }
  287.  
  288.    public int readInt() throws IOException {
  289.       return this.bin.readInt();
  290.    }
  291.  
  292.    public long readLong() throws IOException {
  293.       return this.bin.readLong();
  294.    }
  295.  
  296.    public float readFloat() throws IOException {
  297.       return this.bin.readFloat();
  298.    }
  299.  
  300.    public double readDouble() throws IOException {
  301.       return this.bin.readDouble();
  302.    }
  303.  
  304.    public void readFully(byte[] var1) throws IOException {
  305.       this.bin.readFully(var1, 0, var1.length, false);
  306.    }
  307.  
  308.    public void readFully(byte[] var1, int var2, int var3) throws IOException {
  309.       int var4 = var2 + var3;
  310.       if (var2 >= 0 && var3 >= 0 && var4 <= var1.length && var4 >= 0) {
  311.          this.bin.readFully(var1, var2, var3, false);
  312.       } else {
  313.          throw new IndexOutOfBoundsException();
  314.       }
  315.    }
  316.  
  317.    public int skipBytes(int var1) throws IOException {
  318.       return this.bin.skipBytes(var1);
  319.    }
  320.  
  321.    /** @deprecated */
  322.    @Deprecated
  323.    public String readLine() throws IOException {
  324.       return this.bin.readLine();
  325.    }
  326.  
  327.    public String readUTF() throws IOException {
  328.       return this.bin.readUTF();
  329.    }
  330.  
  331.    private void verifySubclass() {
  332.       Class var1 = this.getClass();
  333.       if (var1 != ObjectInputStream.class) {
  334.          SecurityManager var2 = System.getSecurityManager();
  335.          if (var2 != null) {
  336.             ObjectStreamClass.processQueue(java.io.ObjectInputStream.Caches.subclassAuditsQueue, java.io.ObjectInputStream.Caches.subclassAudits);
  337.             ObjectStreamClass.WeakClassKey var3 = new ObjectStreamClass.WeakClassKey(var1, java.io.ObjectInputStream.Caches.subclassAuditsQueue);
  338.             Boolean var4 = (Boolean)java.io.ObjectInputStream.Caches.subclassAudits.get(var3);
  339.             if (var4 == null) {
  340.                var4 = auditSubclass(var1);
  341.                java.io.ObjectInputStream.Caches.subclassAudits.putIfAbsent(var3, var4);
  342.             }
  343.  
  344.             if (!var4) {
  345.                var2.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
  346.             }
  347.          }
  348.       }
  349.    }
  350.  
  351.    private static boolean auditSubclass(Class var0) {
  352.       Boolean var1 = (Boolean)AccessController.doPrivileged(new 1(var0));
  353.       return var1;
  354.    }
  355.  
  356.    private void clear() {
  357.       this.handles.clear();
  358.       this.vlist.clear();
  359.    }
  360.  
  361.    private Object readObject0(boolean var1) throws IOException {
  362.       boolean var2 = this.bin.getBlockDataMode();
  363.       if (var2) {
  364.          int var3 = this.bin.currentBlockRemaining();
  365.          if (var3 > 0) {
  366.             throw new OptionalDataException(var3);
  367.          }
  368.  
  369.          if (this.defaultDataEnd) {
  370.             throw new OptionalDataException(true);
  371.          }
  372.  
  373.          this.bin.setBlockDataMode(false);
  374.       }
  375.  
  376.       byte var8;
  377.       while((var8 = this.bin.peekByte()) == 121) {
  378.          this.bin.readByte();
  379.          this.handleReset();
  380.       }
  381.  
  382.       ++this.depth;
  383.  
  384.       try {
  385.          switch (var8) {
  386.             case 112:
  387.                Object var16 = this.readNull();
  388.                return var16;
  389.             case 113:
  390.                Object var15 = this.readHandle(var1);
  391.                return var15;
  392.             case 114:
  393.             case 125:
  394.                ObjectStreamClass var14 = this.readClassDesc(var1);
  395.                return var14;
  396.             case 115:
  397.                Object var13 = this.checkResolve(this.readOrdinaryObject(var1));
  398.                return var13;
  399.             case 116:
  400.             case 124:
  401.                Object var12 = this.checkResolve(this.readString(var1));
  402.                return var12;
  403.             case 117:
  404.                Object var11 = this.checkResolve(this.readArray(var1));
  405.                return var11;
  406.             case 118:
  407.                Class var10 = this.readClass(var1);
  408.                return var10;
  409.             case 119:
  410.             case 122:
  411.                if (var2) {
  412.                   this.bin.setBlockDataMode(true);
  413.                   this.bin.peek();
  414.                   throw new OptionalDataException(this.bin.currentBlockRemaining());
  415.                }
  416.  
  417.                throw new StreamCorruptedException("unexpected block data");
  418.             case 120:
  419.                if (var2) {
  420.                   throw new OptionalDataException(true);
  421.                }
  422.  
  423.                throw new StreamCorruptedException("unexpected end of block data");
  424.             case 121:
  425.             default:
  426.                throw new StreamCorruptedException(String.format("invalid type code: %02X", var8));
  427.             case 123:
  428.                IOException var9 = this.readFatalException();
  429.                throw new WriteAbortedException("writing aborted", var9);
  430.             case 126:
  431.                Object var4 = this.checkResolve(this.readEnum(var1));
  432.                return var4;
  433.          }
  434.       } finally {
  435.          --this.depth;
  436.          this.bin.setBlockDataMode(var2);
  437.       }
  438.    }
  439.  
  440.    private Object checkResolve(Object var1) throws IOException {
  441.       if (this.enableResolve && this.handles.lookupException(this.passHandle) == null) {
  442.          Object var2 = this.resolveObject(var1);
  443.          if (var2 != var1) {
  444.             this.handles.setObject(this.passHandle, var2);
  445.          }
  446.  
  447.          return var2;
  448.       } else {
  449.          return var1;
  450.       }
  451.    }
  452.  
  453.    String readTypeString() throws IOException {
  454.       int var1 = this.passHandle;
  455.  
  456.       try {
  457.          byte var2 = this.bin.peekByte();
  458.          switch (var2) {
  459.             case 112:
  460.                String var8 = (String)this.readNull();
  461.                return var8;
  462.             case 113:
  463.                String var7 = (String)this.readHandle(false);
  464.                return var7;
  465.             case 116:
  466.             case 124:
  467.                String var3 = this.readString(false);
  468.                return var3;
  469.             default:
  470.                throw new StreamCorruptedException(String.format("invalid type code: %02X", var2));
  471.          }
  472.       } finally {
  473.          this.passHandle = var1;
  474.       }
  475.    }
  476.  
  477.    private Object readNull() throws IOException {
  478.       if (this.bin.readByte() != 112) {
  479.          throw new InternalError();
  480.       } else {
  481.          this.passHandle = -1;
  482.          return null;
  483.       }
  484.    }
  485.  
  486.    private Object readHandle(boolean var1) throws IOException {
  487.       if (this.bin.readByte() != 113) {
  488.          throw new InternalError();
  489.       } else {
  490.          this.passHandle = this.bin.readInt() - 8257536;
  491.          if (this.passHandle >= 0 && this.passHandle < this.handles.size()) {
  492.             if (var1) {
  493.                throw new InvalidObjectException("cannot read back reference as unshared");
  494.             } else {
  495.                Object var2 = this.handles.lookupObject(this.passHandle);
  496.                if (var2 == unsharedMarker) {
  497.                   throw new InvalidObjectException("cannot read back reference to unshared object");
  498.                } else {
  499.                   return var2;
  500.                }
  501.             }
  502.          } else {
  503.             throw new StreamCorruptedException(String.format("invalid handle value: %08X", this.passHandle + 8257536));
  504.          }
  505.       }
  506.    }
  507.  
  508.    private Class readClass(boolean var1) throws IOException {
  509.       if (this.bin.readByte() != 118) {
  510.          throw new InternalError();
  511.       } else {
  512.          ObjectStreamClass var2 = this.readClassDesc(false);
  513.          Class var3 = var2.forClass();
  514.          this.passHandle = this.handles.assign(var1 ? unsharedMarker : var3);
  515.          ClassNotFoundException var4 = var2.getResolveException();
  516.          if (var4 != null) {
  517.             this.handles.markException(this.passHandle, var4);
  518.          }
  519.  
  520.          this.handles.finish(this.passHandle);
  521.          return var3;
  522.       }
  523.    }
  524.  
  525.    private ObjectStreamClass readClassDesc(boolean var1) throws IOException {
  526.       byte var2 = this.bin.peekByte();
  527.       switch (var2) {
  528.          case 112:
  529.             return (ObjectStreamClass)this.readNull();
  530.          case 113:
  531.             return (ObjectStreamClass)this.readHandle(var1);
  532.          case 114:
  533.             return this.readNonProxyDesc(var1);
  534.          case 125:
  535.             return this.readProxyDesc(var1);
  536.          default:
  537.             throw new StreamCorruptedException(String.format("invalid type code: %02X", var2));
  538.       }
  539.    }
  540.  
  541.    private ObjectStreamClass readProxyDesc(boolean var1) throws IOException {
  542.       if (this.bin.readByte() != 125) {
  543.          throw new InternalError();
  544.       } else {
  545.          ObjectStreamClass var2 = new ObjectStreamClass();
  546.          int var3 = this.handles.assign(var1 ? unsharedMarker : var2);
  547.          this.passHandle = -1;
  548.          int var4 = this.bin.readInt();
  549.          String[] var5 = new String[var4];
  550.  
  551.          for(int var6 = 0; var6 < var4; ++var6) {
  552.             var5[var6] = this.bin.readUTF();
  553.          }
  554.  
  555.          Class var10 = null;
  556.          ClassNotFoundException var7 = null;
  557.          this.bin.setBlockDataMode(true);
  558.  
  559.          try {
  560.             if ((var10 = this.resolveProxyClass(var5)) == null) {
  561.                var7 = new ClassNotFoundException("null class");
  562.             }
  563.          } catch (ClassNotFoundException var9) {
  564.             var7 = var9;
  565.          }
  566.  
  567.          this.skipCustomData();
  568.          var2.initProxy(var10, var7, this.readClassDesc(false));
  569.          this.handles.finish(var3);
  570.          this.passHandle = var3;
  571.          return var2;
  572.       }
  573.    }
  574.  
  575.    private ObjectStreamClass readNonProxyDesc(boolean var1) throws IOException {
  576.       if (this.bin.readByte() != 114) {
  577.          throw new InternalError();
  578.       } else {
  579.          ObjectStreamClass var2 = new ObjectStreamClass();
  580.          int var3 = this.handles.assign(var1 ? unsharedMarker : var2);
  581.          this.passHandle = -1;
  582.          Object var4 = null;
  583.  
  584.          try {
  585.             var10 = this.readClassDescriptor();
  586.          } catch (ClassNotFoundException var9) {
  587.             throw (IOException)(new InvalidClassException("failed to read class descriptor")).initCause(var9);
  588.          }
  589.  
  590.          Class var5 = null;
  591.          ClassNotFoundException var6 = null;
  592.          this.bin.setBlockDataMode(true);
  593.  
  594.          try {
  595.             if ((var5 = this.resolveClass(var10)) == null) {
  596.                var6 = new ClassNotFoundException("null class");
  597.             }
  598.          } catch (ClassNotFoundException var8) {
  599.             var6 = var8;
  600.          }
  601.  
  602.          this.skipCustomData();
  603.          var2.initNonProxy(var10, var5, var6, this.readClassDesc(false));
  604.          this.handles.finish(var3);
  605.          this.passHandle = var3;
  606.          return var2;
  607.       }
  608.    }
  609.  
  610.    private String readString(boolean var1) throws IOException {
  611.       byte var3 = this.bin.readByte();
  612.       String var2;
  613.       switch (var3) {
  614.          case 116:
  615.             var2 = this.bin.readUTF();
  616.             break;
  617.          case 124:
  618.             var2 = this.bin.readLongUTF();
  619.             break;
  620.          default:
  621.             throw new StreamCorruptedException(String.format("invalid type code: %02X", var3));
  622.       }
  623.  
  624.       this.passHandle = this.handles.assign(var1 ? unsharedMarker : var2);
  625.       this.handles.finish(this.passHandle);
  626.       return var2;
  627.    }
  628.  
  629.    private Object readArray(boolean var1) throws IOException {
  630.       if (this.bin.readByte() != 117) {
  631.          throw new InternalError();
  632.       } else {
  633.          ObjectStreamClass var2 = this.readClassDesc(false);
  634.          int var3 = this.bin.readInt();
  635.          Object var4 = null;
  636.          Class var6 = null;
  637.          Class var5;
  638.          if ((var5 = var2.forClass()) != null) {
  639.             var6 = var5.getComponentType();
  640.             var4 = Array.newInstance(var6, var3);
  641.          }
  642.  
  643.          int var7 = this.handles.assign(var1 ? unsharedMarker : var4);
  644.          ClassNotFoundException var8 = var2.getResolveException();
  645.          if (var8 != null) {
  646.             this.handles.markException(var7, var8);
  647.          }
  648.  
  649.          if (var6 == null) {
  650.             for(int var9 = 0; var9 < var3; ++var9) {
  651.                this.readObject0(false);
  652.             }
  653.          } else if (var6.isPrimitive()) {
  654.             if (var6 == Integer.TYPE) {
  655.                this.bin.readInts((int[])var4, 0, var3);
  656.             } else if (var6 == Byte.TYPE) {
  657.                this.bin.readFully((byte[])var4, 0, var3, true);
  658.             } else if (var6 == Long.TYPE) {
  659.                this.bin.readLongs((long[])var4, 0, var3);
  660.             } else if (var6 == Float.TYPE) {
  661.                this.bin.readFloats((float[])var4, 0, var3);
  662.             } else if (var6 == Double.TYPE) {
  663.                this.bin.readDoubles((double[])var4, 0, var3);
  664.             } else if (var6 == Short.TYPE) {
  665.                this.bin.readShorts((short[])var4, 0, var3);
  666.             } else if (var6 == Character.TYPE) {
  667.                this.bin.readChars((char[])var4, 0, var3);
  668.             } else {
  669.                if (var6 != Boolean.TYPE) {
  670.                   throw new InternalError();
  671.                }
  672.  
  673.                this.bin.readBooleans((boolean[])var4, 0, var3);
  674.             }
  675.          } else {
  676.             Object[] var11 = var4;
  677.  
  678.             for(int var10 = 0; var10 < var3; ++var10) {
  679.                var11[var10] = this.readObject0(false);
  680.                this.handles.markDependency(var7, this.passHandle);
  681.             }
  682.          }
  683.  
  684.          this.handles.finish(var7);
  685.          this.passHandle = var7;
  686.          return var4;
  687.       }
  688.    }
  689.  
  690.    private Enum readEnum(boolean var1) throws IOException {
  691.       if (this.bin.readByte() != 126) {
  692.          throw new InternalError();
  693.       } else {
  694.          ObjectStreamClass var2 = this.readClassDesc(false);
  695.          if (!var2.isEnum()) {
  696.             throw new InvalidClassException("non-enum class: " + var2);
  697.          } else {
  698.             int var3 = this.handles.assign(var1 ? unsharedMarker : null);
  699.             ClassNotFoundException var4 = var2.getResolveException();
  700.             if (var4 != null) {
  701.                this.handles.markException(var3, var4);
  702.             }
  703.  
  704.             String var5 = this.readString(false);
  705.             Enum var6 = null;
  706.             Class var7 = var2.forClass();
  707.             if (var7 != null) {
  708.                try {
  709.                   var6 = Enum.valueOf(var7, var5);
  710.                } catch (IllegalArgumentException var9) {
  711.                   throw (IOException)(new InvalidObjectException("enum constant " + var5 + " does not exist in " + var7)).initCause(var9);
  712.                }
  713.  
  714.                if (!var1) {
  715.                   this.handles.setObject(var3, var6);
  716.                }
  717.             }
  718.  
  719.             this.handles.finish(var3);
  720.             this.passHandle = var3;
  721.             return var6;
  722.          }
  723.       }
  724.    }
  725.  
  726.    private Object readOrdinaryObject(boolean var1) throws IOException {
  727.       if (this.bin.readByte() != 115) {
  728.          throw new InternalError();
  729.       } else {
  730.          ObjectStreamClass var2 = this.readClassDesc(false);
  731.          var2.checkDeserialize();
  732.  
  733.          Object var3;
  734.          try {
  735.             var3 = var2.isInstantiable() ? var2.newInstance() : null;
  736.          } catch (Exception var6) {
  737.             throw (IOException)(new InvalidClassException(var2.forClass().getName(), "unable to create instance")).initCause(var6);
  738.          }
  739.  
  740.          this.passHandle = this.handles.assign(var1 ? unsharedMarker : var3);
  741.          ClassNotFoundException var4 = var2.getResolveException();
  742.          if (var4 != null) {
  743.             this.handles.markException(this.passHandle, var4);
  744.          }
  745.  
  746.          if (var2.isExternalizable()) {
  747.             this.readExternalData((Externalizable)var3, var2);
  748.          } else {
  749.             this.readSerialData(var3, var2);
  750.          }
  751.  
  752.          this.handles.finish(this.passHandle);
  753.          if (var3 != null && this.handles.lookupException(this.passHandle) == null && var2.hasReadResolveMethod()) {
  754.             Object var5 = var2.invokeReadResolve(var3);
  755.             if (var1 && var5.getClass().isArray()) {
  756.                var5 = cloneArray(var5);
  757.             }
  758.  
  759.             if (var5 != var3) {
  760.                var3 = var5;
  761.                this.handles.setObject(this.passHandle, var5);
  762.             }
  763.          }
  764.  
  765.          return var3;
  766.       }
  767.    }
  768.  
  769.    private void readExternalData(Externalizable var1, ObjectStreamClass var2) throws IOException {
  770.       CallbackContext var3 = this.curContext;
  771.       this.curContext = null;
  772.       boolean var4 = var2.hasBlockExternalData();
  773.       if (var4) {
  774.          this.bin.setBlockDataMode(true);
  775.       }
  776.  
  777.       if (var1 != null) {
  778.          try {
  779.             var1.readExternal(this);
  780.          } catch (ClassNotFoundException var6) {
  781.             this.handles.markException(this.passHandle, var6);
  782.          }
  783.       }
  784.  
  785.       if (var4) {
  786.          this.skipCustomData();
  787.       }
  788.  
  789.       this.curContext = var3;
  790.    }
  791.  
  792.    private void readSerialData(Object var1, ObjectStreamClass var2) throws IOException {
  793.       ObjectStreamClass.ClassDataSlot[] var3 = var2.getClassDataLayout();
  794.  
  795.       for(int var4 = 0; var4 < var3.length; ++var4) {
  796.          ObjectStreamClass var5 = var3[var4].desc;
  797.          if (var3[var4].hasData) {
  798.             if (var1 != null && var5.hasReadObjectMethod() && this.handles.lookupException(this.passHandle) == null) {
  799.                CallbackContext var6 = this.curContext;
  800.                this.curContext = new CallbackContext(var1, var5);
  801.                this.bin.setBlockDataMode(true);
  802.  
  803.                try {
  804.                   var5.invokeReadObject(var1, this);
  805.                } catch (ClassNotFoundException var11) {
  806.                   this.handles.markException(this.passHandle, var11);
  807.                } finally {
  808.                   this.curContext.setUsed();
  809.                }
  810.  
  811.                this.curContext = var6;
  812.                this.defaultDataEnd = false;
  813.             } else {
  814.                this.defaultReadFields(var1, var5);
  815.             }
  816.  
  817.             if (var5.hasWriteObjectData()) {
  818.                this.skipCustomData();
  819.             } else {
  820.                this.bin.setBlockDataMode(false);
  821.             }
  822.          } else if (var1 != null && var5.hasReadObjectNoDataMethod() && this.handles.lookupException(this.passHandle) == null) {
  823.             var5.invokeReadObjectNoData(var1);
  824.          }
  825.       }
  826.  
  827.    }
  828.  
  829.    private void skipCustomData() throws IOException {
  830.       int var1 = this.passHandle;
  831.  
  832.       while(true) {
  833.          if (this.bin.getBlockDataMode()) {
  834.             this.bin.skipBlockData();
  835.             this.bin.setBlockDataMode(false);
  836.          }
  837.  
  838.          switch (this.bin.peekByte()) {
  839.             case 119:
  840.             case 122:
  841.                this.bin.setBlockDataMode(true);
  842.                break;
  843.             case 120:
  844.                this.bin.readByte();
  845.                this.passHandle = var1;
  846.                return;
  847.             case 121:
  848.             default:
  849.                this.readObject0(false);
  850.          }
  851.       }
  852.    }
  853.  
  854.    private void defaultReadFields(Object var1, ObjectStreamClass var2) throws IOException {
  855.       Class var3 = var2.forClass();
  856.       if (var3 != null && var1 != null && !var3.isInstance(var1)) {
  857.          throw new ClassCastException();
  858.       } else {
  859.          int var4 = var2.getPrimDataSize();
  860.          if (this.primVals == null || this.primVals.length < var4) {
  861.             this.primVals = new byte[var4];
  862.          }
  863.  
  864.          this.bin.readFully(this.primVals, 0, var4, false);
  865.          if (var1 != null) {
  866.             var2.setPrimFieldValues(var1, this.primVals);
  867.          }
  868.  
  869.          int var5 = this.passHandle;
  870.          ObjectStreamField[] var6 = var2.getFields(false);
  871.          Object[] var7 = new Object[var2.getNumObjFields()];
  872.          int var8 = var6.length - var7.length;
  873.  
  874.          for(int var9 = 0; var9 < var7.length; ++var9) {
  875.             ObjectStreamField var10 = var6[var8 + var9];
  876.             var7[var9] = this.readObject0(var10.isUnshared());
  877.             if (var10.getField() != null) {
  878.                this.handles.markDependency(var5, this.passHandle);
  879.             }
  880.          }
  881.  
  882.          if (var1 != null) {
  883.             var2.setObjFieldValues(var1, var7);
  884.          }
  885.  
  886.          this.passHandle = var5;
  887.       }
  888.    }
  889.  
  890.    private IOException readFatalException() throws IOException {
  891.       if (this.bin.readByte() != 123) {
  892.          throw new InternalError();
  893.       } else {
  894.          this.clear();
  895.          return (IOException)this.readObject0(false);
  896.       }
  897.    }
  898.  
  899.    private void handleReset() throws StreamCorruptedException {
  900.       if (this.depth > 0) {
  901.          throw new StreamCorruptedException("unexpected reset; recursion depth: " + this.depth);
  902.       } else {
  903.          this.clear();
  904.       }
  905.    }
  906.  
  907.    private static native void bytesToFloats(byte[] var0, int var1, float[] var2, int var3, int var4);
  908.  
  909.    private static native void bytesToDoubles(byte[] var0, int var1, double[] var2, int var3, int var4);
  910.  
  911.    private static native ClassLoader latestUserDefinedLoader();
  912.  
  913.    private static Object cloneArray(Object var0) {
  914.       if (var0 instanceof Object[]) {
  915.          return ((Object[])((Object[])var0)).clone();
  916.       } else if (var0 instanceof boolean[]) {
  917.          return ((boolean[])((boolean[])var0)).clone();
  918.       } else if (var0 instanceof byte[]) {
  919.          return ((byte[])((byte[])var0)).clone();
  920.       } else if (var0 instanceof char[]) {
  921.          return ((char[])((char[])var0)).clone();
  922.       } else if (var0 instanceof double[]) {
  923.          return ((double[])((double[])var0)).clone();
  924.       } else if (var0 instanceof float[]) {
  925.          return ((float[])((float[])var0)).clone();
  926.       } else if (var0 instanceof int[]) {
  927.          return ((int[])((int[])var0)).clone();
  928.       } else if (var0 instanceof long[]) {
  929.          return ((long[])((long[])var0)).clone();
  930.       } else if (var0 instanceof double[]) {
  931.          return ((double[])((double[])var0)).clone();
  932.       } else {
  933.          throw new AssertionError();
  934.       }
  935.    }
  936.  
  937.    // $FF: synthetic method
  938.    static int access$000(ObjectInputStream var0) {
  939.       return var0.passHandle;
  940.    }
  941.  
  942.    // $FF: synthetic method
  943.    static HandleTable access$100(ObjectInputStream var0) {
  944.       return var0.handles;
  945.    }
  946.  
  947.    // $FF: synthetic method
  948.    static BlockDataInputStream access$200(ObjectInputStream var0) {
  949.       return var0.bin;
  950.    }
  951.  
  952.    // $FF: synthetic method
  953.    static Object access$300(ObjectInputStream var0, boolean var1) throws IOException {
  954.       return var0.readObject0(var1);
  955.    }
  956.  
  957.    // $FF: synthetic method
  958.    static int access$002(ObjectInputStream var0, int var1) {
  959.       return var0.passHandle = var1;
  960.    }
  961.  
  962.    // $FF: synthetic method
  963.    static boolean access$500(ObjectInputStream var0) {
  964.       return var0.defaultDataEnd;
  965.    }
  966.  
  967.    // $FF: synthetic method
  968.    static void access$600(ObjectInputStream var0) throws StreamCorruptedException {
  969.       var0.handleReset();
  970.    }
  971.  
  972.    // $FF: synthetic method
  973.    static void access$700(byte[] var0, int var1, float[] var2, int var3, int var4) {
  974.       bytesToFloats(var0, var1, var2, var3, var4);
  975.    }
  976.  
  977.    // $FF: synthetic method
  978.    static void access$800(byte[] var0, int var1, double[] var2, int var3, int var4) {
  979.       bytesToDoubles(var0, var1, var2, var3, var4);
  980.    }
  981.  
  982.    static {
  983.       primClasses.put("boolean", Boolean.TYPE);
  984.       primClasses.put("byte", Byte.TYPE);
  985.       primClasses.put("char", Character.TYPE);
  986.       primClasses.put("short", Short.TYPE);
  987.       primClasses.put("int", Integer.TYPE);
  988.       primClasses.put("long", Long.TYPE);
  989.       primClasses.put("float", Float.TYPE);
  990.       primClasses.put("double", Double.TYPE);
  991.       primClasses.put("void", Void.TYPE);
  992.    }
  993. }
  994.